/*
Merge k Sorted Lists Total Accepted: 49988 Total Submissions: 237574 My Submissions Question Solution
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

*/

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <fstream>
#include <sstream>
#include <unordered_set>
#include <unordered_map>
#include "print.h"
using namespace std;

/**
* Definition for binary tree*/


void testForStack()
{
	stack<int> mystack;
	mystack.push(10);
	mystack.push(20);
	mystack.top() -= 5;
	cout << "mystack.top() is now " << mystack.top() << endl;
}

void testForIntToString()
{
	int a = 10;
	stringstream ss;
	ss << a;
	string str = ss.str();
	cout << str << endl;

	string str1 = to_string(a);

}


/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/

//MergeSort
class Solution1 {
public:
	ListNode* coreMergeKLists(vector<ListNode*>& lists, int l, int r)
	{
		if (l<r)
		{
			int m = (l + r) / 2;
			return mergeSort(coreMergeKLists(lists,l,m), coreMergeKLists(lists,m+1,r));

		}
	
		return lists[l];
	}


	ListNode* mergeSort(ListNode* l1, ListNode* l2)
	{
		ListNode *temp = new ListNode(-1);

		temp->next = l1;
		 
		ListNode* cur = temp;
		while (l1 != NULL && l2 != NULL)
		{
			if (l1->val < l2->val)
			{
				l1 = l1->next;
			}
			else
			{
				ListNode *next = l2->next;
				cur->next = l2;
				l2->next = l1;
				l2 = next;
			}
			cur = cur->next;

		}
		if (l2!=NULL)
		{
			cur->next= l2;
		}
		return temp->next;
	}
	ListNode* mergeKLists(vector<ListNode*>& lists) {
		
		if (lists.size()==0)
		{
			return NULL;

		}

		return coreMergeKLists(lists,0,lists.size()-1);

	}
};


class Solution {
public:
	
	struct cmp{
		bool operator()(ListNode* l1, ListNode* l2)
		{
			if (l1->val<l2->val)
			{
				return false;
			}
			else{
				return true;
			}
		}
	};
	ListNode* mergeKLists(vector<ListNode*>& lists) {

		if (lists.size() ==0)
		{
			return NULL;
		}
		if (lists.size() ==1)
		{
			return lists[0];
		}

		priority_queue<ListNode*, vector<ListNode*>, cmp> heapNode;

		for (int i = 0; i < lists.size(); i++)
		{
			ListNode *temp = lists[i];
			if (temp!=NULL)
			{
				heapNode.push(temp);

			}
		}

		ListNode* head = NULL; 
		ListNode* pre = head;
		while (heapNode.size() > 0)
		{
			ListNode *cur = heapNode.top();
			heapNode.pop();
			if (head == NULL)
			{
				head = cur;
				pre = head;
			}
			else
			{
				pre->next = cur;
			}

			pre = cur;
			if (cur->next != NULL)
				heapNode.push(cur->next);

			
		}
		return head;
	}
};

/**
* Your BSTIterator will be called like this:
* BSTIterator i = BSTIterator(root);
* while (i.hasNext()) cout << i.next();
*/

int main(int argc, char* argv[])
{

	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	vector<ListNode*> lists;
	lists.push_back(node1);
	lists.push_back(node2);

	string input = "1+2*3";

	printf("%d", 150 / 50 % 5);


	Solution s;

	ListNode *res;
	res = s.mergeKLists(lists);

	//vector<int> result;
	//result = s.diffWaysToCompute(input);



	//res = s.productExceptSelf(nums);
	//int n = 7;
	//ifs1.countPrimes(val);

	//strRes = s.findRepeatedDnaSequences(s1);
	//cout << "The result is : " << result << endl;
	//result = s.partition(str);
	//stackTree.push(p->left);
	//stackTree.push(p->right);
	//if (s1.containsNearbyAlmostDuplicate(vecInt, 1, 2))
	//	cout << " True" << endl;
	//else
	//cout << "false" << endl;
	system("pause");
	return 0;
}
//std::unordered_set<std::string> myset =
//{ "hot", "dot", "dog", "lot", "log" };

//std::cout << "myset contains:";
// for (auto it = myset.begin(); it != myset.end(); ++it)
//std::cout << " " << *it;
//;; std::cout << std::endl;

//TreeNode *root = new TreeNode(1);
//TreeNode *left = new TreeNode(2);
//TreeNode *right = new TreeNode(3);

//root->left = left;
//root->right = right;s
/*
//string s1 = "GAGAGAGAGAGA";
string s1 = "GAGAGAGAGAGA";
vector<string> strRes;

TreeNode *root = new TreeNode(1);
TreeNode *left1 = new TreeNode(2);
TreeNode *left2 = new TreeNode(5);

TreeNode *right1 = new TreeNode(3);
TreeNode *right2 = new TreeNode(4);

root->left = left1;
left1->right = left2;

root->right = right1;
right1->right = right2;

//vector<char> level1({ '1', '1', '1', '1', '0' });
//vector<char> level2({ '1', '1', '0', '1', '0' });
//vector<char> level3({ '1', '1', '0', '0', '0' });
//vector<char> level4({ '0', '0', '0', '0', '0' });


vector<vector<char>> grid;
grid.push_back(level1);
grid.push_back(level2);
grid.push_back(level3);
grid.push_back(level4);ss
ListNode *head = new ListNode(1);
ListNode *head1 = new ListNode(2);
ListNode *head2 = new ListNode(6);
ListNode *head3 = new ListNode(3);
ListNode *head4 = new ListNode(4);
ListNode *head5 = new ListNode(5);

ListNode *head6 = new ListNode(6);

head->next = head1;
head1->next = head2;
head2->next = head3;
head3->next = head4;
head4->next = head5;
head5->next = head6;
int val = 6;
char a1[] = { '1', '0', '1', '0', '0' };
char a2[] = { '1', '0', '1', '1', '0' };
char a3[] = { '1', '1', '1', '1', '1' };
char a4[] = { '1', '0', '0', '1', '0' };

vector<char> level1(a1, a1 + sizeof(a1) / sizeof(char));
vector<char> level2(a1, a1 + sizeof(a1) / sizeof(char));
vector<char> level3(a1, a1 + sizeof(a1) / sizeof(char));
vector<char> level4(a1, a1 + sizeof(a1) / sizeof(char));

vector<vector<char> > martix;
martix.push_back(level1);
martix.push_back(level2);
martix.push_back(level3);
martix.push_back(level4);

Solution s;
int result;
result = s.maximalSquare(martix);
*/
